#include "biblioteca.h"
#include <cstdlib>
#include <cstring>
#include <cstring>
#include <cctype>
//*************************** CONSTRUCTOR  *************************************
Biblioteca::Biblioteca(){
	
     
     char nombre[20];
     //usuarios=new Lista<Usuario>;     
//     usuarios= (Lista<Usuario> *)new Lista<Usuario>;
     
//     libros= (Lista<Libro> *) new Lista<Libro> ;
     //pedidosUsuarios=(Lista<PedidoUsuario> *) new Lista<PedidoUsuario>;
   //  pedidosBiblioteca=(Lista<PedidoBiblioteca> *) new Lista<PedidoBiblioteca>;                           
     

     strcpy(nombre,"libros.txt");           
     cargaLibros(nombre);
//     mostrarLibrosBiblioteca();      
     //system("pause");     
  
     nuevoUsuario();
//     mostrarUsuarios();                   
     //system("pause");           
     
}

//******************************** DESTRUTOR ***********************************
Biblioteca::~Biblioteca(){
      //delete usuarios;
      //delete[] libros;
     // delete[] pedidosUsuarios;
     // delete[] pedidosBiblioteca;                                                      
      };

/*****************************************************************************************************/   
/******    LIBROS       funciones              ***************************************************** */     
/****************************************************************************************************/                    
//----------- CARGAR LOS LIBROS DEL FICHERO EN LA LISTA DE LIBROS ----------------
/**
   @brief Carga los libros del fichero
   @post
*/  
 void Biblioteca::cargaLibros(char *nombreFich){
                  
    string tit,aut,edi,nume,blanco,anio,pre;
 
    int fech;
    float precio;                
    ifstream fich;
    
   
     
    fich.open(nombreFich,ios::in);

      if (!fich)   {
         cout << "ERROR: no se puede abrir el fichero para leer" << endl;
     // CAMBIAR ESTO Y LANZAR EXCEPCION !!!!!
     }
     int i=0;
                       
    while (!fich.eof()){
                       
            getline(fich,tit);                 
            
            getline(fich,aut);
          
            getline(fich,anio);
            fech=atoi(anio.c_str());
        
            getline(fich,edi);
                                  
            getline(fich,nume);
                                    
            getline(fich,pre);
            precio=atof(pre.c_str());
                             
            getline(fich,blanco); // una linea en blanco del .txt
    
            //crea el nuevo libro para despues meterlo en la lista         
            Libro *nuevoLibro;
            nuevoLibro=new Libro(tit,aut,edi,nume,fech,precio);
            libros.inserta(*nuevoLibro,i);
            i++; 
           }
       

}
 
//--------------------   BUSCA  LIBROS EN LA LISTA POR UN VALOR --------------- 
/**
   @brief Buscar un los libros con el campo valor
   @post  devuelve una lista de libros 
*/     
Lista <Libro>  Biblioteca::buscaLibros(string nombreCampo,string valor){
    int i,opcion=0;
    bool encontrado=0;
    Libro *libAux;
    libAux=(Libro *)new Libro;
    Lista <Libro> listLib;
    
    //lowercase
    char *cam,*val;        
    cam=(char *)nombreCampo.c_str();
    val=(char *)valor.c_str();
    nombreCampo=strlwr(cam);
    valor=strlwr(val);                
    opcion=0;
  
    if (nombreCampo!="autores" && nombreCampo!="editorial" && nombreCampo!="titulo" && nombreCampo!="isbn" && nombreCampo!="anyo" && nombreCampo!="precio"){
    
     opcion=0;
     //listLib=NULL;
    }              
    else {
    
          for (i=0;i<=libros.tama();i++){
              libAux=libros.lee(i);   
              if (nombreCampo=="titulo"){
                 if (libAux->comprobarTitulo(valor)){
                    encontrado=1;
                    listLib.aumenta(*libAux);
                    i=libros.tama();                            
                 }
              }
              
              if (nombreCampo=="autores"){
                 if(libAux->comprobarAutores(valor)){
                    encontrado=1;
                    listLib.aumenta(*libAux);                                 
                 }                       
              }
              if (nombreCampo=="editorial"){
                 if (libAux->comprobarEditorial(valor)){
                    encontrado=1;
                    listLib.aumenta(*libAux);                                 
                 }                         
              }                           
              if (nombreCampo=="isbn"){
                 if(libAux->comprobarIsbn(valor)){
                    encontrado=1;
                    listLib.aumenta(*libAux);   
                    i=libros.tama();                              
                    }                           
              }
              if (nombreCampo=="anyo"){            
                 int anio=atoi(valor.c_str());
                 if(libAux->comprobarAnyo(anio)){
                    encontrado=1;
                    listLib.aumenta(*libAux);                                 
                 }              
              }         
              if(nombreCampo=="precio"){
                 float precio=atof(valor.c_str());                                        
                 if (libAux->comprobarPrecio(precio)){
                    encontrado=1;
                    listLib.aumenta(*libAux);                            
                 }                                    
              }                                                                                                              
          }  
    }
              
    return listLib;
           
}  
//--------  BUSCA EN LA LISTA DE LIBROS LIBROS POR TITULO E ISBN ---------------           
/**
   @brief Buscar un  libro por titulo y por isbn 
   @use Cuando encuentra el libro deja de buscar mas y lo devuelve
   @post  devuelve un libro 
*/     
Libro * Biblioteca::buscaLibro(string nombreCampo,string valor){
      int i,opcion=0;
      bool encontrado=0;
      Libro *libAux;
      libAux=(Libro *)new Libro;
      Libro *libRet;
      libRet=(Libro *)new Libro;          
      Lista <Libro> *listLib;
      listLib=(Lista <Libro> *)new Lista <Libro>;
      opcion=0;
      
      //lowercase
      char *cam,*val;        
      cam=(char *)nombreCampo.c_str();
      val=(char *)valor.c_str();
      nombreCampo=strlwr(cam);
      valor=strlwr(val);                
      
//          cout<<"\n-->biblioteca::buscaLibros()"<<"Nombre del campo= "<<nombreCampo<<"  valor = "<<valor<<" "<<endl;          
      if (nombreCampo!="autores" && nombreCampo!="editorial" && nombreCampo!="titulo" && nombreCampo!="isbn" && nombreCampo!="anyo" && nombreCampo!="precio"){
      libRet=NULL;
      }              
      else {
              for (i=0;i<=libros.tama() && encontrado==0;i++){
                  libAux=libros.lee(i);   //cout<<"pos = "<<i<<endl;
                  if (nombreCampo=="titulo"){
                     if (libAux->comprobarTitulo(valor)){
                        encontrado=1;
                        listLib->aumenta(*libAux);
                        i=libros.tama();        
                        libRet=libAux;                    
                     }
                  }
                      
                  if (nombreCampo=="isbn"){
                     if(libAux->comprobarIsbn(valor)){
                        encontrado=1;
                        listLib->aumenta(*libAux);   
                        i=libros.tama();               
                        libRet=libAux;                                           
                        }                           
                  }
                                                                                                         
              }  
      }

      if(encontrado!=1)libRet=NULL;        
      return libRet;                   
}        

/*****************************************************************************************************/
/******   USUARIOS     funciones                ***************************/        
/*****************************************************************************************************/

//-------------------- CONSTRUCTOR ALEATORIO DE USUARIOS -----------------------
/**
   @brief Construtor nuevoUsuario aletarorio
   @post
*/
      
 void Biblioteca::nuevoUsuario(){
      
    Usuario *nuevoUsr;
    nuevoUsr= new Usuario[13];
     string log,nomb,clav;
   log="usr";
   nomb="usuario";
   clav="claveUsuario";     
    int i=0;
//    cout<<"\n ------- Creando Usuarios aleatorios-------------------"<<endl;
    for (i=0;i<10;i++){           
       log="usr";
       nomb="usuario";
       clav="claveUsuario";              
      int  num=rand()%50;
      char numero[3];
      itoa(num,numero,10);

      log=log+numero;
      nomb=nomb+numero;
      clav=clav+numero;        
        nuevoUsr[i].nuevoUsuario(log,nomb,clav);
        usuarios.aumenta(nuevoUsr[i]);      
     }          
     nuevoUsr[11].nuevoUsuario("admin","administrador","admin");     
        usuarios.aumenta(nuevoUsr[11]);              
     nuevoUsr[11].nuevoUsuario("demo","demostracion","demo");     
        usuarios.aumenta(nuevoUsr[11]);                      
}

//------------------------ CREA UN NUEVO USUARIO -----------------------------
/**
   @brief Construtor nuevoUsuario 
   @post
*/     
Usuario * Biblioteca::nuevoUsuario(string logiN , string nombrE,string clavE){
      
    Usuario *nuevoUsr;
    nuevoUsr=new Usuario(logiN ,nombrE,clavE);
    return nuevoUsr;

}

//----------- INICIAR SESION: VALIDACION PARA ENTRA EN LA BIBLIOTECA -----------
/**
   @brief IniciAR  de sesion de usuario
   @post
*/     
Usuario * Biblioteca::iniciarSesionUsuario(string logiN ,string clavE,int *validacion){
      int i;
      bool encontrado=0;
      Usuario *usrAux;
      usrAux=new Usuario;
      
          //cout<<"\n-->biblioteca::iniciarSesionUsuario()"<<logiN<<" & "<<clavE<<"tama= "<<usuarios.tama()<<endl;         
         
      
      for (i=0;i<usuarios.tama() && encontrado==0;i++){
          usrAux=usuarios.lee(i);   
          if (usrAux->validarLogin(logiN)){
              if (usrAux->validarClave(clavE))
                  encontrado=1;
          }
      }                     
      if(encontrado!=1)   usrAux=NULL;
      *validacion=encontrado;           
      return usrAux;
}
//---------------------- MOSTRAR USUARIO -----------------------------
/**
   @brief Mostrar todos los usuario
   @post
*/    
 void Biblioteca::mostrarUsuarios(){
//      usuarios.mostrar_usuarios(); 
}

//------------------------- CAMBIAR LA CLAVE DE UN USUARIO ---------------------
/**
   @brief Cambiar la clave de un usuario
   @post
*/  
void Biblioteca::cambiarUsuarioClave(string claveNueva,Usuario *usrAux){
            usrAux->cambiarClave(claveNueva);
            
}

//------------------  BUSCAR UN USUARIO: para validaar el inicio de sesion -----
/**
   @brief Buscar un usuario
   @post
*/    
     bool Biblioteca::buscaUsuario(string log,string clav){
          int i;
          bool encontrado=0;
          Usuario *usrAux;
          usrAux=new Usuario;
          
//          cout<<"\n-->biblioteca::buscaUsuario()"<<log<<" & "<<clav<<endl;          
          
          for (i=0;i<usuarios.tama() && encontrado==0;i++){
              usrAux=usuarios.lee(i);   
              if (usrAux->validarLogin(log)){
                  if (usrAux->validarClave(clav))
                      encontrado=1;
              }
          }                             
                   
          return encontrado;
                   
     }
/**
   @brief Buscar un usuario
   @post
*/    
 Usuario * Biblioteca::buscaUsuario(string log){
      int i;
      bool encontrado=0;
      Usuario *usrAux;
      usrAux=(Usuario *)new Usuario *;
      
//          cout<<"\n-->biblioteca::buscaUsuario()"<<log<<" & "<<clav<<endl;          
      
      for (i=0;i<usuarios.tama() && encontrado==0;i++){
          usrAux=usuarios.lee(i);   
          if (usrAux->validarLogin(log)){                  
                  encontrado=1;
          }
      }                     

      return usrAux;
               
 }     
/**
   @brief Buscar un usuario
   @post
   
 int Biblioteca::buscaUsuario(Usuario *usu){
         int u;
         u=usuarios.busca(usu);        
         cout<<"------busca : "<<usu;
         return u;                     
 }
     
*/ 
/****************************************************************************************************/                       
/******   PedidoUSUARIOS   funciones           **************************************************** */         
/****************************************************************************************************/                    
//------------------------- CREA UN PEDIDO DE USUARIO ---------------------------
/**
   @brief Crea un pedidoUsuario y lo inserta en la lisat de pedidosUsuarios
   @post
*/      
PedidoUsuario * Biblioteca::creaPedidoUsuario(Usuario *usuario,Libro *libro, int prioridad){

   PedidoUsuario *pedUsr;
   pedUsr =new PedidoUsuario(usuario,libro,prioridad);
   pedidosUsuarios.aumenta(*pedUsr);


  return pedUsr;
  }
//-------------------- pedir biblioteca libro  BORRARLA ------------------------   
/**
   @brief Usuario pide un nuevo libro a la biblioteca pedidoUsuario
   @post
*/      
void Biblioteca::pedirBibliotecaLibro(Usuario *usrSesion,Libro *nuevLib){
   /* Libro *nuevLib;
    nuevLib=new Libro;
    nuevLib=buscarLibroCategoria();
    
    if(nuevLib!=NULL){system("pause");
    
     PedidoUsuario *pedUsr;
     pedUsr=new PedidoUsuario ;
     pedUsr=creaPedidoUsuario(usrSesion,nuevLib,1); 
     pedidosUsuarios.aumenta(*pedUsr);
    }
    else cout<<"libro no existe"<<endl;   */               
}    

//----------------- BUSCA PEDIDOS DE USUARIO PENDIENTES DE UN USUARIO ----------
/**
   @brief Busca los pedidos del usuario usr pendientes de tramitar
   @post devuelve una lista con los pedidos de usuario pte de tramitar
*/      
Lista<PedidoUsuario>  Biblioteca::buscaPedidosUsuarioPendientes(Usuario *usr){
  
  Lista <PedidoUsuario> pedNuev;

  int encontrado=0;
  if(pedidosUsuarios.tama()>0){
     int i,numero;
     Usuario *auxUsr;

     
     Lista <PedidoUsuario> pedAux;
     
     PedidoUsuario *ped;           
     
     for (i=0;i<pedidosUsuarios.tama();i++){
         ped=pedidosUsuarios.lee(i);
         auxUsr=ped->usuarioPedidoUsuario();         
         if (*auxUsr==*usr){         
             if(ped->tramitadoPedidoUsuario()==0){              
                pedNuev.aumenta(*ped);
                encontrado=1;
             }
         }
     }
    
   }
  return pedNuev;
     
}

//----------  BUSCA TODOS LOS PEDIDOS DE USUARIOS PENDIENTES -------------------
/**
   @brief Busca los pedidos del usuario  pendientes de tramitar
   @post devuelve una lista con los pedidos de usuario pte de tramitar
*/      
Lista<PedidoUsuario *>  Biblioteca::buscaPedidosUsuarioPendientes(){
    int i,numero;
    Lista <PedidoUsuario *> pedNuev;
    Usuario *auxUsr;      
    PedidoUsuario *ped;             
    
  if(pedidosUsuarios.tama()>0){  
     
     for (i=0;i<pedidosUsuarios.tama();i++){
         ped=pedidosUsuarios.lee(i);
         if(ped->tramitadoPedidoUsuario()==0){              
            pedNuev.aumenta(ped);
         }
     }

   }
  return pedNuev;
     
}    

//----------  BUSCA TODOS LOS PEDIDOS DE USUARIOS TRAMITADOS -------------------
/**
   @brief Busca los pedidos del usuario  pendientes de tramitar
   @post devuelve una lista con los pedidos de usuario pte de tramitar
*/      
Lista<PedidoUsuario *>  Biblioteca::buscaPedidosUsuarioTramitados(){
    int i,numero;
    Lista <PedidoUsuario *> pedNuev;
    Usuario *auxUsr;      
    PedidoUsuario *ped;             
    
  if(pedidosUsuarios.tama()>0){  
     
     for (i=0;i<pedidosUsuarios.tama();i++){
         ped=pedidosUsuarios.lee(i);
         if(ped->tramitadoPedidoUsuario()==1){              
            pedNuev.aumenta(ped);
         }
     }

   }
  return pedNuev;
     
}   
//----------------- BUSCA PEDIDOS DE USUARIO TRAMITADOS DE UN USUARIO ----------
/**
   @brief busca los pedidos tramitados del usuario usr
   @post lista de pedidos
*/          
Lista<PedidoUsuario> Biblioteca::buscaPedidosUsuarioTramitados(Usuario *usr){
  
  Lista <PedidoUsuario> pedNuev;

  int encontrado=0;
  if(pedidosUsuarios.tama()>0){
     int i,numero;
     Usuario *auxUsr;

     
     Lista <PedidoUsuario> pedAux;
     
     PedidoUsuario *ped;           
     
     for (i=0;i<pedidosUsuarios.tama();i++){
         ped=pedidosUsuarios.lee(i);
         auxUsr=ped->usuarioPedidoUsuario();         
         if (*auxUsr==*usr){         
             if(ped->tramitadoPedidoUsuario()==1){              
                pedNuev.aumenta(*ped);
                encontrado=1;
             }
         }
     }
    
   }
  return pedNuev;
                 
}   
/****************************************************************************************************/                    
/******    PedidoBIBLIOTECA    funciones           **************************************************/                              
/****************************************************************************************************/                    

//-------------------- CREA UN PEDIDO DE BIBLIOTECA VACIO ----------------------
/**
   @brief 
   @post
*/      
PedidoBiblioteca * Biblioteca::abrePedidoBiblioteca(){
                  
     PedidoBiblioteca * nuevPed;
     nuevPed=new PedidoBiblioteca ;
     
     //pedidosBiblioteca.aumenta(*nuevPed);
     
     return nuevPed;                  
}
//----- INCLUYE UN PEDIDO DE BIBLIOTECA A LA LISTA DE PEDIDOS BIBLIOTECA -------
/**
   @brief 
   @post
*/          
void Biblioteca::incluyePedidoBiblioteca(PedidoBiblioteca *pedBiblioteca){
     pedidosBiblioteca.aumenta(*pedBiblioteca);     
}
//--------------------  CIERRA UN PEDIDO DE BIBLIOTECA  ------------------------
/**
   @brief 
   @post
*/          
void Biblioteca::cierraPedidoBiblioteca(PedidoBiblioteca *pedidoBiblioteca){
     pedidoBiblioteca->cierraPedido();
}
//-------------------- TRAMITA UN PEDIDO DE USUARIO  ------------------------                   
/**
   @brief A�ade un Pedido de Usuario  a un pedido de biblioteca
   @post  Modifica el pedido de usuario al estado tramitado =1
   @post  Inserta un nuevo pedido de usuario a un pedido de biblioteca
*/          
void Biblioteca::tramitaPedidoUsuario(PedidoUsuario *pedUsuario,PedidoBiblioteca *pedBiblioteca){

 // pedUsuario->verPedidoUsuario();

  //pedUsuario->tramitaPedido();//ya se cambia en insertaLibro()          
  pedBiblioteca->insertaLibro(pedUsuario);                                       
         
}
  
//------------------ BUSCA LOS PEDIDOS DE BIBLIOTECA PENDIENTES (0)-------------
/**
   @brief  
   @brief BUSCA los pedidos de BIBLIOTECA NO tramitados
   @post
*/          
Lista<PedidoBiblioteca>  Biblioteca::buscaPedidosBibliotecaPendientes(){
   

   Lista<PedidoBiblioteca>  listPedBiblio;
 //  listPedBiblio=new Lista<PedidoBiblioteca> ;
   
   PedidoBiblioteca * listPedBiblioRet;
  // listPedBiblioRet=new PedidoBiblioteca  ;
   
   int i,encontrado=0;
   
   for (i=0;i<pedidosBiblioteca.tama();i++){
       listPedBiblioRet=pedidosBiblioteca.lee(i);
       
       if (listPedBiblioRet->tramitadoPedidoBiblioteca()==0){
        //  cout<<"pte de tramitar"<<endl;
         // listPedBiblioRet->verPedidoBiblioteca();system("pause");
          listPedBiblio.aumenta(*listPedBiblioRet);
          encontrado=1;
       }                                               
   }
 
   
   return listPedBiblio;
}

//------------------ BUSCA LOS PEDIDOS DE BIBLIOTECA TRAMITADO (1)-------------
/**
   @brief BUSCA los pedidos de BIBLIOTECA TRAMITADO
   @post
*/          
Lista<PedidoBiblioteca>   Biblioteca::buscaPedidosBibliotecaTramitados(){
   Lista<PedidoBiblioteca>  listPedBiblio;
   //listPedBiblio=(Lista<PedidoBiblioteca> * )new Lista<PedidoBiblioteca> ;
   
   PedidoBiblioteca * nuevPedBiblio;
   //nuevPedBiblio=(PedidoBiblioteca * )new PedidoBiblioteca ;
   
   int i,encontrado=0;
   
   for (i=0;i<pedidosBiblioteca.tama();i++){
       nuevPedBiblio=pedidosBiblioteca.lee(i);
       
       if (nuevPedBiblio->tramitadoPedidoBiblioteca()==1){
       //   nuevPedBiblio->verPedidoBiblioteca();system("pause");
          listPedBiblio.aumenta(*nuevPedBiblio);
          encontrado=1;
       }                                               
   }

   return listPedBiblio;
}     
     

